+++ /dev/null
-#!/usr/bin/env lua
-
--- If you need filesystem access, use nixio.fs
-local fs = require "nixio.fs"
-
--- LuCI JSON is used for checking the arguments and converting tables to JSON.
-local jsonc = require "luci.jsonc"
-
--- Nixio provides syslog functionality
-local nixio = require "nixio"
-
--- To access /etc/config files, use the uci module
-local UCI = require "luci.model.uci"
-
--- Slight overkill, but leaving room to do log_info etcetera.
-local function log_to_syslog(level, message) nixio.syslog(level, message) end
-
-local function log_error(message)
- log_to_syslog("err", "[luci.example]: " .. message)
-end
-
-local function using_uci_directly(section)
- -- Rather than parse files in /etc/config, you can rely on the
- -- luci.model.uci module.
- local uci = UCI.cursor()
-
- -- https://openwrt.github.io/luci/api/modules/luci.model.uci.html
- local config_name = uci:get("example", section)
-
- uci.unload("example")
-
- if not config_name then
- local msg = "'" .. section .. "' not found in /etc/config/example"
- -- Send the log message to syslog so it can be found with logread
- log_error(msg)
-
- -- Convert a lua table into JSON notation and print to stdout
- -- .stringify() is equivalent to cjson's .encode()
- print(jsonc.stringify({uci_error = msg}))
-
- -- Indicate failure in the return code
- os.exit(1)
- end
-
- return config_name
-end
-
--- The methods table defines all of the APIs to expose to rpcd.
--- rpcd will execute this Lua file with the 'list' argument to discover the
--- method names that can be presented over ubus, as well as any arguments
--- those methods take.
-local methods = {
- -- How to call this API:
- -- echo '{"section": "first"}' | lua /usr/libexec/rpcd/luci.example call get_uci_value
- -- echo '{"section": "does_not_exist"}' | lua /usr/libexec/rpcd/luci.example call get_uci_value
- get_uci_value = {
- -- Args are specified as a table, where the argument type is specified by example
- -- The value is not used as a default.
- args = {section = "a_string"},
- -- A special key of 'call' points to a function definition for execution.
- call = function(args)
- -- A table for the result.
- local r = {}
- r.result = jsonc.stringify({
- example_section = using_uci_directly(args.section)
- })
- -- The 'call' handler will refer to '.code', but also defaults if not found.
- r.code = 0
- -- Return the table object; the call handler will access the attributes
- -- of the table.
- return r
- end
- },
- -- How to call this API:
- -- echo '{}' | lua /usr/libexec/rpcd/luci.example call get_sample1
- -- ubus call luci.example get_sample1
- get_sample1 = {
- call = function()
- local r = {}
- -- This structure does not map well to a JSONMap in the LuCI form setup.
- -- It can be rendered as a table easily enough with loops.
- r.result = jsonc.stringify({
- num_cats = 1,
- num_dogs = 2,
- num_parakeets = 4,
- is_this_real = false,
- not_found = nil
- })
- return r
- end
- },
- -- How to call this API:
- -- echo '{}' | lua /usr/libexec/rpcd/luci.example call get_sample2
- -- ubus call luci.example get_sample2
- get_sample2 = {
- call = function()
- local r = {}
- -- This is the structural data that JSONMap will work with in the JS file
- local data = {
- option_one = {
- name = "Some string value",
- value = "A value string",
- parakeets = {"one", "two", "three"},
- },
- option_two = {
- name = "Another string value",
- value = "And another value",
- parakeets = {3, 4, 5},
- }
- }
- r.result = jsonc.stringify(data)
- return r
- end
- }
-}
-
-local function parseInput()
- -- Input parsing - the RPC daemon calls the Lua script and
- -- sends input to it via stdin, not as an argument on the CLI.
- -- Thus, any testing via the lua interpreter needs to be in the form
- -- echo '{jsondata}' | lua /usr/libexec/rpcd/script call method_name
- local parse = jsonc.new()
- local done, err
-
- while true do
- local chunk = io.read(4096)
- if not chunk then
- break
- elseif not done and not err then
- done, err = parse:parse(chunk)
- end
- end
-
- if not done then
- print(jsonc.stringify({
- error = err or "Incomplete input for argument parsing"
- }))
- os.exit(1)
- end
-
- return parse:get()
-end
-
-local function validateArgs(func, uargs)
- -- Validates that arguments picked out by parseInput actually match
- -- up to the arguments expected by the function being called.
- local method = methods[func]
- if not method then
- print(jsonc.stringify({error = "Method not found in methods table"}))
- os.exit(1)
- end
-
- -- Lua has no length operator for tables, so iterate to get the count
- -- of the keys.
- local n = 0
- for _, _ in pairs(uargs) do n = n + 1 end
-
- -- If the method defines an args table (so empty tables are not allowed),
- -- and there were no args, then give a useful error message about that.
- if method.args and n == 0 then
- print(jsonc.stringify({
- error = "Received empty arguments for " .. func ..
- " but it requires " .. jsonc.stringify(method.args)
- }))
- os.exit(1)
- end
-
- uargs.ubus_rpc_session = nil
-
- local margs = method.args or {}
- for k, v in pairs(uargs) do
- if margs[k] == nil or (v ~= nil and type(v) ~= type(margs[k])) then
- print(jsonc.stringify({
- error = "Invalid argument '" .. k .. "' for " .. func ..
- " it requires " .. jsonc.stringify(method.args)
- }))
- os.exit(1)
- end
- end
-
- return method
-end
-
-if arg[1] == "list" then
- -- When rpcd starts up, it executes all scripts in /usr/libexec/rpcd
- -- passing 'list' as the first argument. This block of code examines
- -- all of the entries in the methods table, and looks for an attribute
- -- called 'args' to see if there are arguments for the method.
- --
- -- The end result is a JSON struct like
- -- {
- -- "api_name": {},
- -- "api2_name": {"host": "some_string"}
- -- }
- --
- -- Which will be converted by ubus to
- -- "api_name":{}
- -- "api2_name":{"host":"String"}
- local _, rv = nil, {}
- for _, method in pairs(methods) do rv[_] = method.args or {} end
- print((jsonc.stringify(rv):gsub(":%[%]", ":{}")))
-elseif arg[1] == "call" then
- -- rpcd will execute the Lua script with a first argument of 'call',
- -- a second argument of the method name, and a third argument that's
- -- stringified JSON.
- --
- -- To debug your script, it's probably easiest to start with direct
- -- execution, as calling via ubus will hide execution errors. For example:
- -- echo '{}' | lua /usr/libexec/rpcd/luci.example call get_sample2
- --
- -- or
- --
- -- echo '{"section": "firstf"}' | /usr/libexec/rpcd/luci.example call get_uci_value
- --
- -- See https://openwrt.org/docs/techref/ubus for more details on using
- -- ubus to call your RPC script (which is what LuCI will be doing).
- local args = parseInput()
- local method = validateArgs(arg[2], args)
- local run = method.call(args)
- -- Use the result from the table which we know to be JSON already.
- -- Anything printed on stdout is sent via rpcd to the caller. Use
- -- the syslog functions, or logging to a file, if you need debug
- -- logs.
- print(run.result)
- -- And exit with the code supplied.
- os.exit(run.code or 0)
-elseif arg[1] == "help" then
- local helptext = [[
-Usage:
-
- To see what methods are exported by this script:
-
- lua luci.example list
-
- To call a method that has no arguments:
-
- echo '{}' | lua luci.example call method_name
-
- To call a method that takes arguments:
-
- echo '{"valid": "json", "argument": "value"}' | lua luci.example call method_name
-
- To call this script via ubus:
-
- ubus call luci.example method_name '{"valid": "json", "argument": "value"}'
-]]
- print(helptext)
-end
projects / project / luci.git / commitdiff